Alright, so welcome back to our introduction to software engineering and we have so far

seen that software engineering is very crucial in software development because if we don't

know how to engineer software appropriately, a lot of things go wrong, wrong decisions

are made, we don't even know what to program, so we have seen that there's quite a few

steps until we actually have the desired result, the software in the end, in the engineering

process and this really starts already with the brainstorming and the requirement specification,

then also the software process, how to implement, are we doing it in a more dynamic approach

where we have the agile methods or more plan driven approach where we have models like

the waterfall model or the V model. Then we also discussed a lot on how to actually communicate,

we have seen that a lot of things go wrong when we do actually the planning of the project and

the requirements engineering, then we've also seen that once we have the specification,

it's not that we're done but we actually have to then build a appropriate software architecture

from that and this actually we looked in the last unit to see what architectural design may be

suitable for our software and now we're going really into the implementation part and here we

are now thinking about common best practices, how to implement software and we have a few design

patterns in here and in particular if you work with object-oriented programming, probably you

have already seen some of them, some of them are kind of intuitive, they make sense, I will try to

give some examples and where these design patterns can come in very handy and then we will see that

there's quite a few of them, I will try to show some of them in detail, others we will walk through

the ideas and then we see that there's actually quite a few design patterns that are on the first

view quite similar but then it's really the implementation and the details that matter

where their benefit actually comes out and sometimes you also decide, you combine those

patterns, some of these patterns are actually derived from each other, others are compatible,

others are kind of in competition and you have to think about how to use those patterns in the

right context. We will not go through all of the design patterns but we will also just have a brief

overview on the more common ones and I can highly recommend that you study, there's a very nice book

by Gamma and colleagues, The Gang of Four and this is like a compendium where you can look up design

patterns and I think it's a very good idea when you're in the brainstorming phase, when you design

architecture and you think about the challenges that you have then every now and then a look into

this book can be very very crucial if you already have a lot of experience in developing software,

you will see oh my god I've been using this design pattern all the time so wow, if I had known this

then I would have you know maybe saved a lot of time or this is why other persons have implemented

that way so it also helps you in understanding how particular software packages are designed

because they have been using exactly those design patterns. So design pattern is a description of

the problem and the essence of its solution so that the solution may be reused in different

settings according to Somerville. You could say it's essentially a best practice of software

engineering, a best practice of coding and it describes an elementary solution proposal for

software problems and these design patterns they occur again and again and it's really nice because

then if you know about these patterns you can prepare a proposed solution and you can also

communicate more easily with other software engineers when you're talking about a possible

solution because oh let's use that pattern and then the other person already knows oh yeah this

is a good idea and I know we can't do it because of this and that so it also helps you to communicate

with other software engineers because sometimes the ideas they you know they have nuances and

if you say okay let's implement that pattern and then you know it's important that the nuances

are right and if you want to but you can also change the pattern you will also see that quite

a few of them they can be adopted to certain tasks quite easily. Alright so the gang of four

has written this book design patterns and what's really nice about it and why it became so popular

they were able to to extract those patterns that appear over and over again and then and assigned

a meaningful name which makes communication easier because there's a name oh yeah that's

that pattern let's use that pattern and it also contains a description of the problem where the